package com.how2java.springboot.service.impl;


import com.how2java.springboot.mapper.OrderItemMapper;
import com.how2java.springboot.mapper.OrderMainMapper;
import com.how2java.springboot.po.OrderItemPO;
import com.how2java.springboot.po.OrderMainPO;
import com.how2java.springboot.request.ApiResponse;
import com.how2java.springboot.service.ApiService;
import com.how2java.springboot.service.OrderService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.List;

/**
 * 订单服务实现类
 * 处理订单同步、保存的具体业务逻辑
 */
@Service
@Slf4j
@RequiredArgsConstructor
public class OrderServiceImpl implements OrderService {

    private final OrderMainMapper orderMainPOMapper;
    private final OrderItemMapper orderItemPOMapper;
    private final ApiService apiService;

    @Value("${order.api.page-size:1000}")
    private Integer pageSize;

    /**
     * 同步近1天多的订单数据
     * 逻辑：查询近2天的订单（避免遗漏跨天更新），分页获取并保存
     */
    @Override
    public void syncRecentOrders() {
        log.info("===== 开始同步近1天多的订单数据 =====");
        try {
            // 1. 计算时间范围（当前时间 至 2天前）
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Calendar calendar = Calendar.getInstance();
            String endTime = sdf.format(calendar.getTime()); // 结束时间：当前时间

            calendar.add(Calendar.DAY_OF_YEAR, -2); // 往前推2天
            String startTime = sdf.format(calendar.getTime()); // 开始时间：2天前

            log.info("订单同步时间范围：{} 至 {}", startTime, endTime);

            // 2. 分页查询所有订单
            int pageNumber = 1;
            while (true) {
                // 调用API查询订单
                ApiResponse response = apiService.queryOrders(
                        startTime, endTime, "拼多多", pageNumber, pageSize);

                // 3. 处理响应结果
                if (response == null || response.getRows() == null || response.getRows().isEmpty()) {
                    log.info("第{}页无订单数据，同步结束", pageNumber);
                    break;
                }

                // 4. 批量保存当前页订单
                List<OrderMainPO> orderList = response.getRows();
                batchSaveOrders(orderList);
                log.info("已同步第{}页订单，数量：{}，总页数：{}",
                        pageNumber, orderList.size(), response.getPages());

                // 5. 判断是否还有下一页
                if (pageNumber >= response.getPages()) {
                    log.info("已同步至最后一页（第{}页），同步完成", pageNumber);
                    break;
                }
                pageNumber++;
            }

            log.info("===== 订单同步完成 =====");
        } catch (Exception e) {
            log.error("订单同步失败", e);
        }
    }

    /**
     * 保存单个订单（带事务）
     * 逻辑：1. 处理支付信息 -> 2. 保存主订单（插入或更新） -> 3. 处理订单项（先删后增）
     */
    @Override
    @Transactional(rollbackFor = Exception.class) // 事务注解：任何异常都回滚
    public void saveOrder(OrderMainPO orderMainPO) {
        // 校验订单数据
        if (orderMainPO == null || orderMainPO.getSoId() == null) {
            log.warn("跳过保存：订单数据为空或订单号(soId)不存在");
            return;
        }
        String soId = orderMainPO.getSoId();
        log.debug("开始处理订单：{}", soId);
        orderMainPOMapper.insertOrUpdate(orderMainPO);
        log.debug("订单主表已保存：{}", soId);
        // 3. 处理订单项（先删除旧数据，再插入新数据）
        handleOrderItems(soId, orderMainPO.getItems());
        log.debug("订单处理完成：{}", soId);
    }

    /**
     * 批量保存订单列表
     */
    @Override
    public void batchSaveOrders(List<OrderMainPO> orderList) {
        if (orderList == null || orderList.isEmpty()) {
            log.info("订单列表为空，无需保存");
            return;
        }
        // 循环调用单订单保存方法（每个订单单独事务）
        orderList.forEach(this::saveOrder);
        log.info("批量保存完成，总订单数：{}", orderList.size());
    }

    /**
     * 根据订单号查询完整订单信息
     */
//    @Override
//    public OrderMainPO getOrderBySoId(String soId) {
//        if (soId == null || soId.trim().isEmpty()) {
//            log.warn("查询订单失败：订单号(soId)为空");
//            return null;
//        }
//
//        // 1. 查询主订单
//        OrderMainPO orderMainPO = orderMainPOMapper.selectBySoId(soId);
//        if (orderMainPO == null) {
//            log.debug("订单不存在：{}", soId);
//            return null;
//        }
//
//        // 2. 关联查询订单项
//        List<OrderItemPO> items = orderItemPOMapper.selectBySoId(soId);
//        orderMainPO.setItems(items);
//
//        log.debug("查询订单成功：{}，包含订单项数：{}", soId, items.size());
//        return orderMainPO;
//    }

    /**
     * 处理订单项（先删除旧数据，再插入新数据）
     */
    private void handleOrderItems(String soId, List<OrderItemPO> items) {
        if (items == null || items.isEmpty()) {
            log.debug("订单{}无订单项，无需处理", soId);
            return;
        }

        // 1. 删除旧订单项
        orderItemPOMapper.deleteBySoId(soId);
        log.debug("订单{}旧订单项已删除", soId);

        // 2. 批量插入新订单项（设置关联的订单号）
        items.forEach(item -> item.setSoId(soId));
        orderItemPOMapper.batchInsert(items);
        log.debug("订单{}新订单项已插入，数量：{}", soId, items.size());
    }
}